Please address the comments from this code review:
## Individual Comments

### Comment 1
<location> `crates/orcid-works-cli/src/main.rs:131` </location>
<code_context>
 #[tokio::main]
 async fn main() -> Result<()> {
-    tracing_subscriber::fmt().init();
+    let cli = Cli::parse();
+
+    // initialise logger
</code_context>

<issue_to_address>
Cli is parsed twice, which may lead to inconsistent state or wasted computation.

Pass the parsed CLI arguments from `main` to `run` to avoid duplicate parsing and ensure consistency.
</issue_to_address>

### Comment 2
<location> `crates/orcid-works-cli/src/io.rs:105` </location>
<code_context>
-        return Err(e);
+    if let Err(e) = temp.persist(path).map_err(|e| e.error) {
+        let eid = Uuid::new_v4();
+        debug!("E[{eid}] error: e");
+        error!("E[{eid}] atomic rename failure path={}", path.display());
+        return Err(e).with_context(|| {
</code_context>

<issue_to_address>
The debug log prints a literal 'e' instead of the error value.

Change the log statement to use `{e}` so the actual error is printed.
</issue_to_address>

### Comment 3
<location> `crates/orcid-works-cli/src/api.rs:48` </location>
<code_context>
+        }
+    };

     if res.error_for_status_ref().is_err() {
         let status = res.status();
         let body = res.text().await.unwrap_or_default();
</code_context>

<issue_to_address>
The error body is always read, even for large responses, which may impact performance.

Limit the size of the response body read for error reporting, or truncate logged output to reduce memory usage.
</issue_to_address>

<suggested_fix>
<<<<<<< SEARCH
        let status = res.status();
        let body = res.text().await.unwrap_or_default();

        let eid = Uuid::new_v4();
        error!("E[{eid}] HTTP {status}");
        debug!("E[{eid}] url={url}");
        debug!("E[{eid}] response body={body}");
        bail!("E[{eid}] HTTP {status}");
=======
        use tokio::io::AsyncReadExt;
        use std::cmp;

        let status = res.status();
        // Limit error body to 4096 bytes
        let mut body = String::new();
        let mut stream = res.bytes_stream();
        let mut total_bytes = 0;
        const MAX_ERROR_BODY: usize = 4096;
        while let Some(chunk) = stream.next().await {
            match chunk {
                Ok(bytes) => {
                    let take = cmp::min(MAX_ERROR_BODY - total_bytes, bytes.len());
                    body.push_str(&String::from_utf8_lossy(&bytes[..take]));
                    total_bytes += take;
                    if total_bytes >= MAX_ERROR_BODY {
                        break;
                    }
                }
                Err(_) => break,
            }
        }
        let truncated = total_bytes >= MAX_ERROR_BODY;

        let eid = Uuid::new_v4();
        error!("E[{eid}] HTTP {status}");
        debug!("E[{eid}] url={url}");
        if truncated {
            debug!("E[{eid}] response body (truncated to {MAX_ERROR_BODY} bytes)={body}");
        } else {
            debug!("E[{eid}] response body={body}");
        }
        bail!("E[{eid}] HTTP {status}");
>>>>>>> REPLACE

</suggested_fix>